QA on the line, not a walk through the maze

Stand at the end of a modern assembly line (Samsung, Toyota, any of them) and watch what happens when a solder joint comes out cold. Nobody scraps the phone. Nobody rebuilds the car. The part failed inspection at its station, against a known tolerance, and got kicked back right there. The line is a sequence of small, deterministic operations, each with a spec, a jig, and a gate. Quality isn't a final exam. It's built into every step.

Software's default in the AI era is the opposite of this, and we think that's the whole problem.

The maze, from the inside out

Two dominant approaches, both mazes. The first: describe the whole application, regenerate the whole application, and hope the new diff didn't quietly break the eleven things you weren't looking at. The second: hand an agent the goal and let it wander: a walk through a random forest from the inside out, no map, every run a different path, none of them reproducible, each step billed by the token.

Both feel like progress because something is always moving. But you can't inspect a maze. There are no stations, no tolerances, no place a failure localizes to. When something's wrong you regenerate and re-roll the dice, or you send the agent back into the trees.

The line, instead

We treat building software like deterministic manufacturing. Four parts, borrowed straight from the factory floor:

• The deterministic core is the stamped chassis. Jig-fixed parts with zero variance (the data layer, the permissions, the routes) produced identically every run. You don't inspect a part that can't vary.
• The refinement steps are named stations. Each does one thing to the work and hands off. Small, ordered, and known, not a single monolithic "generate everything."
• The business rules are the tolerances. The spec each station's output must meet. This is Live Logic: totals reconcile, tax sits in band, no duplicates: pass or hold, with the reason attached.
• The judge signals are the inline QA gates. A reward or eval at each station that accepts or holds the part right there, and feeds what it learned forward. That's the grading loop: we judge the residual at each step, not the whole car at the end.

What the line buys you

Localized correction. A failure names its station and its rule. You fix the step, not the vehicle. Nobody re-mills the whole engine block to move one hole.

Reproducibility. Same inputs, same line, same unit, every time. You can re-run the exact process that produced any past result, which a maze can never promise.

Compounding. Every tolerance we validate becomes a permanent jig. The line gets more precise and never un-learns it, where a regen starts from scratch and a maze forgets the path the moment it exits.

Cost. No full regeneration, no per-step wander tax. You pay to refine the one station that needed it, once.

Why this is the new philosophy

The industry is optimizing the maze: faster agents, cheaper tokens, better search through the forest. We think that's the wrong axis. The win isn't a faster walk through randomness; it's not walking through randomness at all. Deterministic parts where the answer is fixed, named refinement steps where it isn't, business rules as tolerances, and a judge at every station. A line feels like nothing dramatic is happening, until a finished, inspected unit rolls off the end the same way, every time.

We chose the line.